Developer CD Series 1992 June: ROMin Holiday/ADC Developer CD (1992-06) (''ROMin Holiday'')_iso/Developer Connection - 06-1992.iso/Periodicals/develop/develop 8 code/TValidText/UDateTimeUtilities.inc1.p

Text File | 1991-10-09 | 5.8 KB | 250 lines | [TEXT/MPS ]

{*******************************************************************************
UDateTimeUtilities.inc1.p
    This file contains the implementations of a number of routines which help
    make the Script Manager more useable.
*******************************************************************************}

{###############################################################################
Implementation Globals (global extent, local scope)
###############################################################################}

VAR
    pDateCache:            DateCacheRecord;{ Used by Script Manager string calls }



{###############################################################################
Unit Initialization
###############################################################################}

{------------------------------------------------------------------------------}
{$S AInit}

PROCEDURE InitUDateTimeUtilities;
    BEGIN
    FailOSErr(InitDateCache(@pDateCache));
    END;  { InitUDateTimeUtilities }


{###############################################################################
Global Routines
###############################################################################}

{------------------------------------------------------------------------------}
{$S Date_Seg}

PROCEDURE InitLongDateRec(
                    VAR    dateRec:        LongDateRec;
                        toValue:        INTEGER);
    { This routine places the given value in each field of the given rec }

    VAR
        i:            INTEGER;

    BEGIN
    WITH dateRec DO
        BEGIN
        FOR i := 0 to 13 DO
            list[i] := toValue;
        END;  { with dateRec }
    END;  { InitLongDateRec }

{------------------------------------------------------------------------------}
{$S Date_Seg}

PROCEDURE SecsToRec(
                        dateSecs:        LongDateTime;
                    VAR    dateRec:        LongDateRec);
    BEGIN
    IF (dateSecs = kNotADate)
    THEN
        InitLongDateRec(dateRec, 0)
    ELSE
        LongSecs2Date(dateSecs, dateRec);        { Script Manager routine }
    END;  { SecsToRec }

{------------------------------------------------------------------------------}
{$S Date_Seg}

PROCEDURE RecToSecs(
                    VAR    dateRec:        LongDateRec;    { not changed }
                    VAR    dateSecs:        LongDateTime);
    BEGIN
    LongDate2Secs(dateRec, dateSecs);            { Script Manager routine }
    END;  { RecToSecs }

{------------------------------------------------------------------------------}
{$S Date_Seg}

PROCEDURE DateToString(
                        dateSecs:        LongDateTime;
                        theDateForm:    DateForm;
                    VAR    theDate:        Str255);

    BEGIN
    IF (dateSecs = kNotADate)
    THEN
        theDate := ''
    ELSE
        BEGIN
        IULDateString(dateSecs,                    { Script Manager routine }
                      theDateForm,
                      theDate,
                      NIL);        { use system's 'itl0' }
        END;
    END;  { DateToString }

{------------------------------------------------------------------------------}
{$S Date_Seg}

PROCEDURE TimeToString(
                        timeSecs:        LONGINT;
                        wantSeconds:    BOOLEAN;
                    VAR    theTime:        Str255);
    VAR
        longTime:        LongDateTime;

    BEGIN
    IF (timeSecs = kNotATime)
    THEN
        theTime := ''
    ELSE
        BEGIN
        longTime := timeSecs;
        IULTimeString(longTime,                    { Script Manager routine }
                      wantSeconds,
                      theTime,
                      NIL);        { use system's 'itl0' }
        END;
    END;  { TimeToString }

{------------------------------------------------------------------------------}
{$S Date_Seg}

FUNCTION  StringToDate(
                        dateStr:        Str255;
                    VAR    dateSecs:        LongDateTime)
                        :String2DateStatus;

    VAR
        dateRec:        LongDateRec;
        lengthUsed:        LONGINT;
        status:        String2DateStatus;

    BEGIN
    { must initialize dateRec }
    InitLongDateRec(dateRec, 0);

    status := String2Date(                        { Script Manager routine }
                            @dateStr[1],
                            ord(dateStr[0]),
                            @pDateCache,
                            lengthUsed,
                            dateRec);

    IF (status >= 0)
    THEN
        RecToSecs(dateRec, dateSecs)
    ELSE
        dateSecs := kNotADate;

    StringToDate := status;
    END;  { StringToDate }

{------------------------------------------------------------------------------}
{$S Date_Seg}

FUNCTION  StringToTime(
                        timeStr:        Str255;
                    VAR    timeSecs:        LONGINT)
                        :String2DateStatus;

    VAR
        timeRec:        LongDateRec;
        lengthUsed:        LONGINT;
        status:            String2DateStatus;
        longSecs:        LongDateTime;

    BEGIN
    { must initialize timeRec }
    InitLongDateRec(timeRec, 0);

    status := String2Time(            { Script Manager routine }
                            @timeStr[1],
                            ord(timeStr[0]),
                            @pDateCache,
                            lengthUsed,
                            timeRec);

    IF (status >= 0)
    THEN
        BEGIN
        WITH timeRec DO
            BEGIN
            timeSecs := (hour   * LONGINT(kSecsPerHour))   +
                        (minute * LONGINT(kSecsPerMinute)) +
                        second;
            END;
        END
    ELSE
        timeSecs := kNotATime;

    StringToTime := status;
    END;  { StringToTime }

{------------------------------------------------------------------------------}
{$S Date_Seg}

FUNCTION  LongDateTimeToTime(
                    VAR    dateSecs:        LongDateTime)
                        :LONGINT;
    { This routine extracts the current time from the given LongDateTime. }
    VAR
        theRec:            LongDateRec;

    BEGIN
    SecsToRec(dateSecs, theRec);

    WITH theRec DO
        BEGIN
        LongDateTimeToTime := (hour   * LONGINT(kSecsPerHour))   +
                              (minute * LONGINT(kSecsPerMinute)) +
                              second;
        END;
    END;  { LongDateTimeToTime }

{------------------------------------------------------------------------------}
{$S Date_Seg}

PROCEDURE GetCurrentDate(
                    VAR    dateSecs:        LongDateTime);
    { Returns the current date. }
    VAR
        dateTime:        LONGINT;
        result:            ARRAY[1..2] OF LONGINT;

    BEGIN
    GetDateTime(dateTime);

    result[1] := 0;
    result[2] := dateTime;
    dateSecs := LongDateTime(result);
    END;  { GetCurrentDate }

{------------------------------------------------------------------------------}
{$S Date_Seg}

PROCEDURE GetCurrentTime(
                    VAR    timeSecs:        LONGINT);
    { Returns the current time. }
    VAR
        currentDate:    LongDateTime;

    BEGIN
    GetCurrentDate(currentDate);

    timeSecs := LongDateTimeToTime(currentDate);
    END;  { GetCurrentTime }


{------------------------------------------------------------------------------}